home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
EnigmA Amiga Run 1996 February
/
EnigmA AMIGA RUN 04 (1996)(G.R. Edizioni)(IT)[!][issue 1996-02][Skylink CD III].iso
/
earcd
/
comm2
/
termsorc.lha
/
Extras
/
Source
/
term-source.lha
/
termConfig.c
< prev
next >
Wrap
C/C++ Source or Header
|
1995-09-26
|
87KB
|
3,625 lines
/*
** termConfig.c
**
** Configuration processing routines
**
** Copyright © 1990-1995 by Olaf `Olsen' Barthel
** All Rights Reserved
**
** :ts=4
*/
#include "termGlobal.h"
/* Reset routine function pointer. */
typedef VOID (* RESET)(APTR,STRPTR);
/* Local routines. */
STATIC BYTE ReadSystemPrefs(STRPTR Name,ULONG ID,APTR Data,LONG Size,LONG Count);
STATIC VOID ResetSerialConfig(struct SerialSettings *SerialConfig);
STATIC VOID ResetModem(struct ModemSettings *ModemConfig);
STATIC VOID ResetScreen(struct ScreenSettings *ScreenConfig);
STATIC VOID ResetTerminal(struct TerminalSettings *TerminalConfig);
STATIC VOID ResetEmulation(struct EmulationSettings *EmulationConfig);
STATIC VOID ResetClip(struct ClipSettings *ClipConfig);
STATIC VOID ResetCapture(struct CaptureSettings *CaptureConfig);
STATIC VOID ResetFile(struct FileSettings *FileConfig,STRPTR PathBuffer);
STATIC VOID ResetPath(struct PathSettings *PathConfig,STRPTR PathBuffer);
STATIC VOID ResetMisc(struct MiscSettings *MiscConfig);
STATIC VOID ResetCommand(struct CommandSettings *CommandConfig);
STATIC VOID ResetTransfer(struct TransferSettings *TransferConfig,STRPTR DefaultLib);
STATIC VOID ResetTranslationFile(STRPTR Arg,STRPTR PathBuffer);
STATIC VOID ResetMacroFile(STRPTR Arg,STRPTR PathBuffer);
STATIC VOID ResetCursorFile(STRPTR Arg,STRPTR PathBuffer);
STATIC VOID ResetFastMacroFile(STRPTR Arg,STRPTR PathBuffer);
STATIC BYTE WriteConfigChunk(struct IFFHandle *Handle,struct Configuration *Config,BYTE Type,APTR TempBuffer,STRPTR Password);
STATIC BYTE WriteConfigChunks(struct IFFHandle *Handle,struct Configuration *Config,APTR TempBuffer,STRPTR Password);
STATIC UBYTE IsConfigChunk(ULONG ID);
STATIC BYTE ReadConfigChunk(struct IFFHandle *Handle,struct Configuration *Config,UBYTE Type,LONG Len,STRPTR Password);
STATIC UWORD SizeTable[] =
{
sizeof(struct SerialSettings),
sizeof(struct ModemSettings),
sizeof(struct CommandSettings),
sizeof(struct ScreenSettings),
sizeof(struct TerminalSettings),
sizeof(struct PathSettings),
sizeof(struct MiscSettings),
sizeof(struct ClipSettings),
sizeof(struct CaptureSettings),
sizeof(struct FileSettings),
sizeof(struct EmulationSettings),
sizeof(struct TransferSettings),
MAX_FILENAME_LENGTH, // Translation file name
MAX_FILENAME_LENGTH, // Macro file name
MAX_FILENAME_LENGTH, // Cursor file name
MAX_FILENAME_LENGTH, // Fast macro file name
};
STATIC RESET ResetTable[] =
{
(RESET)ResetSerialConfig,
(RESET)ResetModem,
(RESET)ResetCommand,
(RESET)ResetScreen,
(RESET)ResetTerminal,
ResetPath,
(RESET)ResetMisc,
(RESET)ResetClip,
(RESET)ResetCapture,
ResetFile,
(RESET)ResetEmulation,
ResetTransfer,
(RESET)ResetTranslationFile,
(RESET)ResetMacroFile,
(RESET)ResetCursorFile,
(RESET)ResetFastMacroFile
};
STATIC ULONG TypeTable[] =
{
ID_SERL,
ID_MODM,
ID_COMD,
ID_SCRN,
ID_TRML,
ID_PATH,
ID_MISC,
ID_CLIP,
ID_CPTR,
ID_FILE,
ID_EMLN,
ID_XFER,
ID_XLNM,
ID_MFNM,
ID_CRNM,
ID_FMNM
};
#define NUM_STOPS (sizeof(Stops) / (2 * sizeof(ULONG)))
STATIC LONG Stops[] =
{
ID_TERM,ID_CAT,
ID_TERM,ID_VERS,
ID_TERM,ID_DIAL,
ID_TERM,ID_DATE,
ID_TERM,ID_PHON,
ID_TERM,ID_PSWD,
ID_TERM,ID_SERL,
ID_TERM,ID_MODM,
ID_TERM,ID_COMD,
ID_TERM,ID_SCRN,
ID_TERM,ID_TRML,
ID_TERM,ID_PATH,
ID_TERM,ID_MISC,
ID_TERM,ID_CLIP,
ID_TERM,ID_CPTR,
ID_TERM,ID_FILE,
ID_TERM,ID_EMLN,
ID_TERM,ID_XFER,
ID_TERM,ID_WINF,
ID_TERM,ID_GRUP,
ID_TERM,ID_XLNM,
ID_TERM,ID_MFNM,
ID_TERM,ID_CRNM,
ID_TERM,ID_FMNM
};
STATIC BYTE FontPrefsRead = FALSE,
FontPrefsReadFailed = FALSE;
STATIC struct FontPrefs FontPrefs[3];
STATIC BYTE ScreenModePrefsRead = FALSE,
ScreenModePrefsReadFailed = FALSE;
STATIC struct ScreenModePrefs ScreenModePrefs;
enum { CR_IGNORE,CR_ASCR,CR_ASCRLF };
enum { LF_IGNORE,LF_ASLF,LF_ASLFCR };
VOID __regargs
FinalFix(struct Configuration *Config,BOOLEAN IsPhonebook,LONG Version,LONG Revision)
{
if(Config)
{
if(Version < 4 || (Version == 4 && Revision < 3))
{
if(Config -> TransferConfig && Config -> MiscConfig)
{
Config -> TransferConfig -> OverridePath = Config -> MiscConfig -> OverridePath;
Config -> TransferConfig -> SetArchivedBit = Config -> MiscConfig -> SetArchivedBit;
Config -> TransferConfig -> IdentifyFiles = Config -> MiscConfig -> IdentifyFiles;
Config -> TransferConfig -> TransferIcons = Config -> MiscConfig -> TransferIcons;
Config -> TransferConfig -> PerfMeter = Config -> MiscConfig -> PerfMeter;
Config -> TransferConfig -> HideUploadIcon = Config -> MiscConfig -> HideUploadIcon;
}
}
if(Version < 4 || (Version == 4 && Revision < 4))
{
if(Config -> TerminalConfig && Config -> MiscConfig)
Config -> MiscConfig -> AlertMode = Config -> TerminalConfig -> AlertMode;
}
}
}
VOID __regargs
FixOldConfig(struct Configuration *Config,UBYTE ConfigChunkType,BOOLEAN IsPhonebook,LONG Version,LONG Revision)
{
if((Version == 3 && Revision < 6) || Version < 3)
{
if(ConfigChunkType == PREF_CLIP)
Config -> ClipConfig -> ConvertLF = TRUE;
if(ConfigChunkType == PREF_SERIAL)
Config -> SerialConfig -> UseOwnDevUnit = TRUE;
if(ConfigChunkType == PREF_MISC)
Config -> MiscConfig -> ProtectiveMode = TRUE;
if(ConfigChunkType == PREF_SCREEN)
{
Config -> ScreenConfig -> UsePens = TRUE;
Config -> ScreenConfig -> Depth = 0;
Config -> ScreenConfig -> PenColourMode = 42; // Avoid trouble
}
if(ConfigChunkType == PREF_TRANSFER)
{
WORD i;
Config -> TransferConfig -> MangleFileNames = FALSE;
if(Config -> TransferConfig -> ASCIIUploadLibrary[0])
Config -> TransferConfig -> ASCIIUploadType = XFER_XPR;
if(Config -> TransferConfig -> ASCIIDownloadLibrary[0])
Config -> TransferConfig -> ASCIIDownloadType = XFER_XPR;
if(Config -> TransferConfig -> TextUploadLibrary[0])
Config -> TransferConfig -> TextUploadType = XFER_XPR;
if(Config -> TransferConfig -> TextDownloadLibrary[0])
Config -> TransferConfig -> TextDownloadType = XFER_XPR;
if(Config -> TransferConfig -> BinaryUploadLibrary[0])
Config -> TransferConfig -> BinaryUploadType = XFER_XPR;
if(Config -> TransferConfig -> BinaryDownloadLibrary[0])
Config -> TransferConfig -> BinaryDownloadType = XFER_XPR;
for(i = 0 ; i < strlen(Config -> TransferConfig -> DefaultLibrary) - 6 ; i++)
{
if(!Strnicmp(&Config -> TransferConfig -> DefaultLibrary[i],"zmodem",6))
{
strcpy(Config -> TransferConfig -> Signatures[TRANSFERSIG_DEFAULTUPLOAD] . Signature,"*\030B01");
Config -> TransferConfig -> Signatures[TRANSFERSIG_DEFAULTUPLOAD] . Length = strlen(Config -> TransferConfig -> Signatures[TRANSFERSIG_DEFAULTUPLOAD] . Signature);
break;
}
}
}
if(ConfigChunkType == PREF_MODEM)
Config -> ModemConfig -> AbortHangsUp = FALSE;
if(ConfigChunkType == PREF_COMMAND && IsPhonebook)
{
strcpy(Config -> CommandConfig -> LoginMacro,Config -> CommandConfig -> StartupMacro);
memset(Config -> CommandConfig -> StartupMacro,0,sizeof(Config -> CommandConfig -> StartupMacro));
}
if(ConfigChunkType == PREF_CAPTURE)
Config -> CaptureConfig -> SearchHistory = 10;
if(ConfigChunkType == PREF_EMULATION)
{
if(Config -> EmulationConfig -> DestructiveBackspace < 0 || Config -> EmulationConfig -> DestructiveBackspace > 2)
Config -> EmulationConfig -> DestructiveBackspace = 1;
}
}
if((Version == 4 && Revision < 1) || Version < 4)
{
if(ConfigChunkType == PREF_CLIP)
Config -> ClipConfig -> ConvertLF = TRUE;
if(ConfigChunkType == PREF_SERIAL)
{
Config -> SerialConfig -> xONxOFF = FALSE;
Config -> SerialConfig -> PassThrough = TRUE;
}
if(ConfigChunkType == PREF_MISC)
Config -> MiscConfig -> ProtectiveMode = TRUE;
if(ConfigChunkType == PREF_MODEM)
{
Config -> ModemConfig -> RedialDelay = (Config -> ModemConfig -> RedialDelay / 6) * 60 + (Config -> ModemConfig -> RedialDelay % 6) * 10;
Config -> ModemConfig -> TimeToConnect = (Config -> ModemConfig -> TimeToConnect / 6) * 60 + (Config -> ModemConfig -> TimeToConnect % 6) * 10;
Config -> ModemConfig -> VerboseDialing = FALSE;
}
if(ConfigChunkType == PREF_TERMINAL)
{
switch(Config -> TerminalConfig -> SendCR)
{
case CR_IGNORE:
Config -> TerminalConfig -> SendCR = EOL_IGNORE;
break;
case CR_ASCR:
Config -> TerminalConfig -> SendCR = EOL_CR;
break;
case CR_ASCRLF:
Config -> TerminalConfig -> SendCR = EOL_CRLF;
break;
}
switch(Config -> TerminalConfig -> ReceiveCR)
{
case CR_IGNORE:
Config -> TerminalConfig -> ReceiveCR = EOL_IGNORE;
break;
case CR_ASCR:
Config -> TerminalConfig -> ReceiveCR = EOL_CR;
break;
case CR_ASCRLF:
Config -> TerminalConfig -> ReceiveCR = EOL_CRLF;
break;
}
switch(Config -> TerminalConfig -> SendLF)
{
case LF_IGNORE:
Config -> TerminalConfig -> SendLF = EOL_IGNORE;
break;
case LF_ASLF:
Config -> TerminalConfig -> SendLF = EOL_LF;
break;
case LF_ASLFCR:
Config -> TerminalConfig -> SendLF = EOL_LFCR;
break;
}
switch(Config -> TerminalConfig -> ReceiveLF)
{
case LF_IGNORE:
Config -> TerminalConfig -> ReceiveLF = EOL_IGNORE;
break;
case LF_ASLF:
Config -> TerminalConfig -> ReceiveLF = EOL_LF;
break;
case LF_ASLFCR:
Config -> TerminalConfig -> ReceiveLF = EOL_LFCR;
break;
}
}
if(ConfigChunkType == PREF_TRANSFER)
{
WORD i;
if(Config -> TransferConfig -> ASCIIUploadLibrary[0])
Config -> TransferConfig -> ASCIIUploadType = XFER_XPR;
if(Config -> TransferConfig -> ASCIIDownloadLibrary[0])
Config -> TransferConfig -> ASCIIDownloadType = XFER_XPR;
if(Config -> TransferConfig -> TextUploadLibrary[0])
Config -> TransferConfig -> TextUploadType = XFER_XPR;
if(Config -> TransferConfig -> TextDownloadLibrary[0])
Config -> TransferConfig -> TextDownloadType = XFER_XPR;
if(Config -> TransferConfig -> BinaryUploadLibrary[0])
Config -> TransferConfig -> BinaryUploadType = XFER_XPR;
if(Config -> TransferConfig -> BinaryDownloadLibrary[0])
Config -> TransferConfig -> BinaryDownloadType = XFER_XPR;
for(i = 0 ; i < strlen(Config -> TransferConfig -> DefaultLibrary) - 6 ; i++)
{
if(!Strnicmp(&Config -> TransferConfig -> DefaultLibrary[i],"zmodem",6))
{
strcpy(Config -> TransferConfig -> Signatures[TRANSFERSIG_DEFAULTUPLOAD] . Signature,"*\030B01");
Config -> TransferConfig -> Signatures[TRANSFERSIG_DEFAULTUPLOAD] . Length = strlen(Config -> TransferConfig -> Signatures[TRANSFERSIG_DEFAULTUPLOAD] . Signature);
break;
}
}
switch(Config -> TransferConfig -> SendCR)
{
case CR_IGNORE:
Config -> TransferConfig -> SendCR = EOL_IGNORE;
break;
case CR_ASCR:
Config -> TransferConfig -> SendCR = EOL_CR;
break;
case CR_ASCRLF:
Config -> TransferConfig -> SendCR = EOL_CRLF;
break;
}
switch(Config -> TransferConfig -> ReceiveCR)
{
case CR_IGNORE:
Config -> TransferConfig -> ReceiveCR = EOL_IGNORE;
break;
case CR_ASCR:
Config -> TransferConfig -> ReceiveCR = EOL_CR;
break;
case CR_ASCRLF:
Config -> TransferConfig -> ReceiveCR = EOL_CRLF;
break;
}
switch(Config -> TransferConfig -> SendLF)
{
case LF_IGNORE:
Config -> TransferConfig -> SendLF = EOL_IGNORE;
break;
case LF_ASLF:
Config -> TransferConfig -> SendLF = EOL_LF;
break;
case LF_ASLFCR:
Config -> TransferConfig -> SendLF = EOL_LFCR;
break;
}
switch(Config -> TransferConfig -> ReceiveLF)
{
case LF_IGNORE:
Config -> TransferConfig -> ReceiveLF = EOL_IGNORE;
break;
case LF_ASLF:
Config -> TransferConfig -> ReceiveLF = EOL_LF;
break;
case LF_ASLFCR:
Config -> TransferConfig -> ReceiveLF = EOL_LFCR;
break;
}
}
}
if(Version == 4 && Revision < 3)
{
if(ConfigChunkType == PREF_CLIP)
Config -> ClipConfig -> ConvertLF = TRUE;
if(ConfigChunkType == PREF_SERIAL)
{
Config -> SerialConfig -> xONxOFF = FALSE;
Config -> SerialConfig -> PassThrough = TRUE;
}
if(ConfigChunkType == PREF_MISC)
Config -> MiscConfig -> ProtectiveMode = TRUE;
if(ConfigChunkType == PREF_TRANSFER)
{
WORD i;
for(i = 0 ; i < strlen(Config -> TransferConfig -> DefaultLibrary) - 6 ; i++)
{
if(!Strnicmp(&Config -> TransferConfig -> DefaultLibrary[i],"zmodem",6))
{
strcpy(Config -> TransferConfig -> Signatures[TRANSFERSIG_DEFAULTUPLOAD] . Signature,"*\030B01");
Config -> TransferConfig -> Signatures[TRANSFERSIG_DEFAULTUPLOAD] . Length = strlen(Config -> TransferConfig -> Signatures[TRANSFERSIG_DEFAULTUPLOAD] . Signature);
break;
}
}
if(Config -> TransferConfig -> ASCIIUploadLibrary[0])
Config -> TransferConfig -> ASCIIUploadType = XFER_XPR;
if(Config -> TransferConfig -> ASCIIDownloadLibrary[0])
Config -> TransferConfig -> ASCIIDownloadType = XFER_XPR;
if(Config -> TransferConfig -> InternalASCIIUpload)
Config -> TransferConfig -> ASCIIUploadType = XFER_INTERNAL;
if(Config -> TransferConfig -> InternalASCIIDownload)
Config -> TransferConfig -> ASCIIDownloadType = XFER_INTERNAL;
if(Config -> TransferConfig -> TextUploadLibrary[0])
Config -> TransferConfig -> TextUploadType = XFER_XPR;
if(Config -> TransferConfig -> TextDownloadLibrary[0])
Config -> TransferConfig -> TextDownloadType = XFER_XPR;
if(Config -> TransferConfig -> BinaryUploadLibrary[0])
Config -> TransferConfig -> BinaryUploadType = XFER_XPR;
if(Config -> TransferConfig -> BinaryDownloadLibrary[0])
Config -> TransferConfig -> BinaryDownloadType = XFER_XPR;
}
}
}
VOID __regargs
FixScreenPens(struct ScreenSettings *ScreenConfig)
{
WORD i,Count;
for(Count = 0, i = DETAILPEN ; i <= BARTRIMPEN ; i++)
{
if(ScreenConfig -> PenArray[i])
Count++;
}
if(!Count)
ScreenConfig -> UsePens = TRUE;
}
/* ReadSystemPrefs():
*
* Reads the system preferences settings.
*/
STATIC BYTE
ReadSystemPrefs(STRPTR Name,ULONG ID,APTR Data,LONG Size,LONG Count)
{
struct IFFHandle *Handle;
BYTE Success = FALSE;
LONG Error = 0;
/* Allocate an IFF handle. */
if(Handle = AllocIFF())
{
/* Open the preferences settings file. */
if(Handle -> iff_Stream = Open(Name,MODE_OLDFILE))
{
/* Make it known as a DOS file handle. */
InitIFFasDOS(Handle);
/* Open the file for reading. */
if(!(Error = OpenIFF(Handle,IFFF_READ)))
{
/* Stop at the `body' chunk. */
if(!(Error = StopChunk(Handle,ID_PREF,ID)))
{
/* Look for it... */
while(!ParseIFF(Handle,IFFPARSE_SCAN))
{
/* Read the data. */
if(ReadChunkBytes(Handle,Data,Size) == Size)
{
Success = TRUE;
if(Count)
{
Count--;
Data = (APTR)((ULONG)Data + Size);
}
else
break;
}
else
{
Error = IoErr();
Success = FALSE;
break;
}
}
}
/* Close the handle. */
CloseIFF(Handle);
}
/* Release the handle. */
Close(Handle -> iff_Stream);
}
else
Error = IoErr();
/* Clean up. */
FreeIFF(Handle);
}
else
Error = ERR_NO_MEM;
if(Error)
SetIoErr(Error);
/* Return sucess/failure. */
return(Success);
}
STATIC VOID
ResetSerialConfig(struct SerialSettings *SerialConfig)
{
STATIC BYTE SerialPrefsRead = FALSE,
SerialPrefsReadFailed = FALSE;
STATIC struct SerialPrefs SerialPrefs;
memset(SerialConfig,0,sizeof(*SerialConfig));
/* The program will only try to read the preferences
* settings once; if the first access failed, no
* other accesses will be made.
*/
if(!SerialPrefsRead && !SerialPrefsReadFailed)
SerialPrefsReadFailed = ReadSystemPrefs("ENV:sys/serial.prefs",ID_SERL,&SerialPrefs,sizeof(SerialPrefs),1) ^ TRUE;
/* Did we succeed in reading the file? */
if(!SerialPrefsRead)
{
SerialConfig -> BaudRate = 19200;
SerialConfig -> BitsPerChar = 8;
SerialConfig -> Parity = PARITY_NONE;
SerialConfig -> StopBits = 1;
SerialConfig -> HandshakingProtocol = HANDSHAKING_RTSCTS_DSR;
SerialConfig -> SerialBufferSize = 32768;
}
else
{
/* Fill in the common data. */
SerialConfig -> BaudRate = SerialPrefs . sp_BaudRate;
SerialConfig -> SerialBufferSize = SerialPrefs . sp_InputBuffer;
SerialConfig -> BitsPerChar = SerialPrefs . sp_BitsPerChar;
SerialConfig -> StopBits = SerialPrefs . sp_StopBits;
/* Convert the handshaking mode. */
switch(SerialPrefs . sp_InputHandshake)
{
case HSHAKE_NONE:
SerialConfig -> HandshakingProtocol = HANDSHAKING_NONE;
break;
case HSHAKE_RTS:
SerialConfig -> HandshakingProtocol = HANDSHAKING_RTSCTS_DSR;
break;
default:
SerialConfig -> HandshakingProtocol = HANDSHAKING_NONE;
break;
}
/* Convert the parity settings. */
if(SerialPrefs . sp_Parity <= PARITY_SPACE)
SerialConfig -> Parity = SerialPrefs . sp_Parity;
else
SerialConfig -> Parity = PARITY_NONE;
SerialPrefsRead = TRUE;
}
strcpy(SerialConfig -> SerialDevice,SERIALNAME);
SerialConfig -> Duplex = DUPLEX_FULL;
SerialConfig -> HighSpeed = FALSE;
SerialConfig -> Shared = FALSE;
SerialConfig -> BreakLength = 250000;
SerialConfig -> UnitNumber = 0;
SerialConfig -> StripBit8 = FALSE;
SerialConfig -> CheckCarrier = FALSE;
SerialConfig -> xONxOFF = FALSE;
SerialConfig -> PassThrough = TRUE;
SerialConfig -> IgnoreCarrier = FALSE;
SerialConfig -> Quantum = 256;
SerialConfig -> UseNet = FALSE;
SerialConfig -> NetID = 0002;
SerialConfig -> SatisfyODURequests = ODU_RELEASE;
SerialConfig -> LastVersionSaved = 0;
SerialConfig -> LastRevisionSaved = 0;
SerialConfig -> DirectConnection = FALSE;
SerialConfig -> ReleaseODUWhenOnline = FALSE;
SerialConfig -> ReleaseODUWhenDialing = FALSE;
SerialConfig -> NoODUIfShared = FALSE;
SerialConfig -> Pad = 0;
}
STATIC VOID
ResetModem(struct ModemSettings *ModemConfig)
{
memset(ModemConfig,0,sizeof(*ModemConfig));
strcpy(ModemConfig -> ModemInit, "ATE1V1Q0\\r");
strcpy(ModemConfig -> ModemExit, "");
strcpy(ModemConfig -> ModemHangup, "~~~~+++~~~~ATH0\\r");
strcpy(ModemConfig -> DialPrefix, "ATD\\w");
strcpy(ModemConfig -> DialSuffix, "\\r");
strcpy(ModemConfig -> NoCarrier, "NO CARRIER");
strcpy(ModemConfig -> NoDialTone, "NO DIALTONE");
strcpy(ModemConfig -> Connect, "CONNECT");
strcpy(ModemConfig -> Voice, "VOICE");
strcpy(ModemConfig -> Ring, "RING");
strcpy(ModemConfig -> Busy, "BUSY");
strcpy(ModemConfig -> Ok, "OK");
strcpy(ModemConfig -> Error, "ERROR");
ModemConfig -> RedialDelay = 20;
ModemConfig -> DialRetries = 10;
ModemConfig -> DialTimeout = 60;
ModemConfig -> ConnectAutoBaud = FALSE;
ModemConfig -> DropDTR = FALSE;
ModemConfig -> RedialAfterHangup = FALSE;
ModemConfig -> NoCarrierIsBusy = TRUE;
ModemConfig -> ConnectLimit = 0;
ModemConfig -> ConnectLimitMacro[0] = 0;
ModemConfig -> TimeToConnect = 0;
ModemConfig -> VerboseDialing = FALSE;
ModemConfig -> DialMode = DIALMODE_PULSE;
ModemConfig -> DoNotSendMainModemCommands = FALSE;
ModemConfig -> InterDialDelay = 0;
ModemConfig -> CharSendDelay = 0;
strcpy(ModemConfig -> PBX_Prefix, "0,,,");
ModemConfig -> PBX_Mode = FALSE;
ModemConfig -> Pad = 0;
}
STATIC VOID
ResetScreen(struct ScreenSettings *ScreenConfig)
{
ULONG DisplayID;
struct Screen *PubScreen;
memset(ScreenConfig,0,sizeof(struct ScreenSettings));
if(!FontPrefsRead && !FontPrefsReadFailed)
FontPrefsReadFailed = ReadSystemPrefs("ENV:sys/font.prefs",ID_FONT,FontPrefs,sizeof(struct FontPrefs),3) ^ TRUE;
/*
if(!ScreenModePrefsRead && !ScreenModePrefsReadFailed)
ScreenModePrefsReadFailed = ReadSystemPrefs("ENV:sys/screenmode.prefs",ID_SCRM,&ScreenModePrefs,sizeof(ScreenModePrefs),1) ^ TRUE;
if(!ScreenModePrefsReadFailed)
{
DisplayID = ScreenModePrefs . smp_DisplayID;
if(ModeNotAvailable(DisplayID))
DisplayID = INVALID_ID;
}
*/
DisplayID = INVALID_ID;
strcpy(ScreenConfig -> FontName,"topaz.font");
ScreenConfig -> FontHeight = 8;
if(!FontPrefsReadFailed)
{
LONG i;
for(i = 0 ; i < 3 ; i++)
{
if(FontPrefs[i] . fp_Type == FP_SCREENFONT)
{
strcpy(ScreenConfig -> FontName,FontPrefs[i] . fp_Name);
ScreenConfig -> FontHeight = FontPrefs[i] . fp_TextAttr . ta_YSize;
break;
}
}
}
if(DisplayID == INVALID_ID)
{
if(PubScreen = LockPubScreen(NULL))
{
DisplayID = GetVPModeID(&PubScreen -> ViewPort);
UnlockPubScreen(NULL,PubScreen);
}
else
DisplayID = DEFAULT_MONITOR_ID | HIRESLACE_KEY;
}
ScreenConfig -> DisplayMode = DisplayID;
ScreenConfig -> ColourMode = COLOUR_AMIGA;
ScreenConfig -> MakeScreenPublic = TRUE;
ScreenConfig -> ShanghaiWindows = FALSE;
ScreenConfig -> TitleBar = TRUE;
ScreenConfig -> StatusLine = STATUSLINE_STANDARD;
ScreenConfig -> Blinking = TRUE;
ScreenConfig -> FasterLayout = TRUE;
ScreenConfig -> UseWorkbench = FALSE;
ScreenConfig -> PubScreenName[0] = 0;
ScreenConfig -> TimeMode = ONLINETIME_BOTH;
ScreenConfig -> UsePens = TRUE;
ScreenConfig -> PenColourMode = COLOUR_AMIGA;
ScreenConfig -> DisplayWidth = 0;
ScreenConfig -> DisplayHeight = 0;
ScreenConfig -> OverscanType = OSCAN_TEXT;
ScreenConfig -> ShareScreen = FALSE;
ScreenConfig -> SplitStatus = FALSE;
ScreenConfig -> UseColours96 = FALSE;
}
STATIC VOID
ResetTerminal(struct TerminalSettings *TerminalConfig)
{
memset(TerminalConfig,0,sizeof(struct TerminalSettings));
if(!FontPrefsRead && !FontPrefsReadFailed)
FontPrefsReadFailed = ReadSystemPrefs("ENV:sys/font.prefs",ID_FONT,FontPrefs,sizeof(struct FontPrefs),3) ^ TRUE;
strcpy(TerminalConfig -> TextFontName,"topaz.font");
TerminalConfig -> TextFontHeight = 8;
strcpy(TerminalConfig -> IBMFontName,"IBM.font");
TerminalConfig -> IBMFontHeight = 8;
if(!FontPrefsReadFailed)
{
LONG i;
for(i = 0 ; i < 3 ; i++)
{
if(FontPrefs[i] . fp_Type == FP_SYSFONT)
{
strcpy(TerminalConfig -> TextFontName,FontPrefs[i] . fp_Name);
TerminalConfig -> TextFontHeight = FontPrefs[i] . fp_TextAttr . ta_YSize;
if(TerminalConfig -> TextFontHeight == 8 || TerminalConfig -> TextFontHeight == 11)
TerminalConfig -> IBMFontHeight = TerminalConfig -> TextFontHeight;
break;
}
}
}
TerminalConfig -> BellMode = BELL_AUDIBLE;
TerminalConfig -> AlertMode = ALERT_BEEP_SCREEN;
TerminalConfig -> EmulationMode = EMULATION_ANSIVT100;
TerminalConfig -> FontMode = FONT_STANDARD;
TerminalConfig -> SendCR = EOL_CR;
TerminalConfig -> SendLF = EOL_LF;
TerminalConfig -> ReceiveCR = EOL_CR;
TerminalConfig -> ReceiveLF = EOL_LF;
TerminalConfig -> NumColumns = 0;
TerminalConfig -> NumLines = 0;
TerminalConfig -> KeyMapFileName[0] = 0;
TerminalConfig -> EmulationFileName[0] = 0;
TerminalConfig -> BeepFileName[0] = 0;
TerminalConfig -> UseTerminalTask = FALSE;
TerminalConfig -> Pad = 0;
}
STATIC VOID
ResetEmulation(struct EmulationSettings *EmulationConfig)
{
WORD i;
memset(EmulationConfig,0,sizeof(*EmulationConfig));
EmulationConfig -> CursorMode = KEYMODE_STANDARD;
EmulationConfig -> NumericMode = KEYMODE_STANDARD;
EmulationConfig -> NewLineMode = FALSE;
EmulationConfig -> InsertMode = FALSE;
EmulationConfig -> LineWrap = TRUE;
EmulationConfig -> CursorWrap = FALSE;
EmulationConfig -> FontScale = SCALE_NORMAL;
EmulationConfig -> ScrollMode = SCROLL_JUMP;
EmulationConfig -> DestructiveBackspace = FALSE;
EmulationConfig -> SwapBSDelete = FALSE;
EmulationConfig -> PrinterEnabled = TRUE;
EmulationConfig -> AnswerBack[0] = 0;
EmulationConfig -> CLSResetsCursor = 0;
EmulationConfig -> KeysLocked = FALSE;
EmulationConfig -> MaxScroll = 0;
EmulationConfig -> MaxJump = 1;
EmulationConfig -> CursorLocked = FALSE;
EmulationConfig -> FontLocked = FALSE;
EmulationConfig -> LockWrapping = FALSE;
EmulationConfig -> LockStyle = FALSE;
EmulationConfig -> LockColour = FALSE;
EmulationConfig -> UseStandardPens = TRUE;
for(i = TEXTATTR_UNDERLINE ; i <= TEXTATTR_INVERSE ; i++)
EmulationConfig -> Attributes[i] = i;
for(i = 0 ; i < 16 ; i++)
EmulationConfig -> Pens[i] = i;
EmulationConfig -> TerminalType = TERMINAL_VT200;
}
STATIC VOID
ResetClip(struct ClipSettings *ClipConfig)
{
memset(ClipConfig,0,sizeof(*ClipConfig));
ClipConfig -> ClipboardUnit = 0;
ClipConfig -> LineDelay = 0;
ClipConfig -> CharDelay = 0;
ClipConfig -> InsertPrefix[0] = 0;
strcpy(ClipConfig -> InsertSuffix,"\\r");
ClipConfig -> LinePrompt[0] = 0;
ClipConfig -> SendTimeout = 0;
ClipConfig -> PacingMode = PACE_DIRECT;
ClipConfig -> ConvertLF = TRUE;
}
STATIC VOID
ResetCapture(struct CaptureSettings *CaptureConfig)
{
memset(CaptureConfig,0,sizeof(*CaptureConfig));
CaptureConfig -> LogActions = FALSE;
CaptureConfig -> LogCall = FALSE;
CaptureConfig -> LogFileName[0] = 0;
CaptureConfig -> MaxBufferSize = 0;
CaptureConfig -> BufferEnabled = TRUE;
CaptureConfig -> ConnectAutoCapture = FALSE;
CaptureConfig -> CaptureFilterMode = FILTER_BOTH;
CaptureConfig -> CapturePath[0] = 0;
CaptureConfig -> CallLogFileName[0] = 0;
CaptureConfig -> BufferPath[0] = 0;
CaptureConfig -> AutoCaptureDate = AUTOCAPTURE_DATE_NAME;
CaptureConfig -> SearchHistory = 10;
CaptureConfig -> OpenBufferWindow = BUFFER_END;
CaptureConfig -> OpenBufferScreen = BUFFER_TOP;
CaptureConfig -> BufferScreenPosition = SCREEN_CENTRE;
CaptureConfig -> BufferWidth = 80;
CaptureConfig -> RememberBufferWindow = FALSE;
CaptureConfig -> RememberBufferScreen = FALSE;
CaptureConfig -> BufferScreenMode = INVALID_ID;
CaptureConfig -> ConvertChars = FALSE;
CaptureConfig -> BufferMode = BUFFERMODE_FLOW;
}
STATIC VOID
ResetTranslationFile(STRPTR Arg,STRPTR PathBuffer)
{
memset(Arg,0,MAX_FILENAME_LENGTH);
if(!PathBuffer)
PathBuffer = "TERM:config";
if(!LastTranslation[0])
{
strcpy(LastTranslation,PathBuffer);
AddPart(LastTranslation,"translation.prefs",MAX_FILENAME_LENGTH);
}
strcpy(Arg,LastTranslation);
}
STATIC VOID
ResetMacroFile(STRPTR Arg,STRPTR PathBuffer)
{
memset(Arg,0,MAX_FILENAME_LENGTH);
if(!PathBuffer)
PathBuffer = "TERM:config";
if(!LastMacros[0])
{
strcpy(LastMacros,PathBuffer);
AddPart(LastMacros,"functionkeys.prefs",MAX_FILENAME_LENGTH);
}
strcpy(Arg,LastMacros);
}
STATIC VOID
ResetCursorFile(STRPTR Arg,STRPTR PathBuffer)
{
memset(Arg,0,MAX_FILENAME_LENGTH);
if(!PathBuffer)
PathBuffer = "TERM:config";
if(!LastCursorKeys[0])
{
strcpy(LastCursorKeys,PathBuffer);
AddPart(LastCursorKeys,"cursorkeys.prefs",MAX_FILENAME_LENGTH);
}
strcpy(Arg,LastCursorKeys);
}
STATIC VOID
ResetFastMacroFile(STRPTR Arg,STRPTR PathBuffer)
{
memset(Arg,0,MAX_FILENAME_LENGTH);
if(!PathBuffer)
PathBuffer = "TERM:config";
if(!LastFastMacros[0])
{
strcpy(LastFastMacros,PathBuffer);
AddPart(LastFastMacros,"fastmacros.prefs",MAX_FILENAME_LENGTH);
}
strcpy(Arg,LastFastMacros);
}
STATIC VOID
ResetFile(struct FileSettings *FileConfig,STRPTR PathBuffer)
{
if(FileConfig)
{
memset(FileConfig,0,sizeof(*FileConfig));
if(!PathBuffer)
PathBuffer = "TERM:config";
strcpy(FileConfig -> ProtocolFileName,"xprzmodem.library");
if(!LastTranslation[0])
{
strcpy(LastTranslation,PathBuffer);
AddPart(LastTranslation,"translation.prefs",MAX_FILENAME_LENGTH);
}
strcpy(FileConfig -> TranslationFileName,LastTranslation);
if(!LastMacros[0])
{
strcpy(LastMacros,PathBuffer);
AddPart(LastMacros,"functionkeys.prefs",MAX_FILENAME_LENGTH);
}
strcpy(FileConfig -> MacroFileName,LastMacros);
if(!LastFastMacros[0])
{
strcpy(LastFastMacros,PathBuffer);
AddPart(LastFastMacros,"fastmacros.prefs",MAX_FILENAME_LENGTH);
}
strcpy(FileConfig -> FastMacroFileName,LastFastMacros);
if(!LastCursorKeys[0])
{
strcpy(LastCursorKeys,PathBuffer);
AddPart(LastCursorKeys,"cursorkeys.prefs",MAX_FILENAME_LENGTH);
}
strcpy(FileConfig -> CursorFileName,LastCursorKeys);
}
}
STATIC VOID
ResetPath(struct PathSettings *PathConfig,STRPTR PathBuffer)
{
memset(PathConfig,0,sizeof(*PathConfig));
if(!PathBuffer)
PathBuffer = "TERM:config";
strcpy(PathConfig -> DefaultStorage,PathBuffer);
PathConfig -> ASCIIUploadPath[0] = 0;
PathConfig -> ASCIIDownloadPath[0] = 0;
PathConfig -> TextUploadPath[0] = 0;
PathConfig -> TextDownloadPath[0] = 0;
PathConfig -> BinaryUploadPath[0] = 0;
PathConfig -> BinaryDownloadPath[0] = 0;
strcpy(PathConfig -> HelpFile,"PROGDIR:term.guide");
strcpy(PathConfig -> DefaultStorage,PathBuffer);
GetEnvDOS(PathConfig -> Editor,"EDITOR");
}
STATIC VOID
ResetMisc(struct MiscSettings *MiscConfig)
{
memset(MiscConfig,0,sizeof(*MiscConfig));
MiscConfig -> Priority = 1;
MiscConfig -> BackupConfig = FALSE;
MiscConfig -> OpenFastMacroPanel = FALSE;
MiscConfig -> ReleaseDevice = TRUE;
MiscConfig -> TransferServer = TRUE;
MiscConfig -> EmulationServer = TRUE;
MiscConfig -> OverridePath = TRUE;
MiscConfig -> AutoUpload = TRUE;
MiscConfig -> SetArchivedBit = FALSE;
MiscConfig -> IdentifyFiles = IDENTIFY_FILETYPE;
MiscConfig -> TransferIcons = FALSE;
MiscConfig -> CreateIcons = FALSE;
MiscConfig -> SimpleIO = FALSE;
MiscConfig -> PerfMeter = FALSE;
MiscConfig -> IOBufferSize = 32768;
MiscConfig -> HideUploadIcon = FALSE;
MiscConfig -> ProtectiveMode = TRUE;
MiscConfig -> AlertMode = ALERT_BEEP_SCREEN;
MiscConfig -> RequesterMode = REQUESTERMODE_IGNORE;
MiscConfig -> RequesterLeft = 0;
MiscConfig -> RequesterTop = 0;
MiscConfig -> RequesterWidth = 0;
MiscConfig -> RequesterHeight = 0;
}
STATIC VOID
ResetCommand(struct CommandSettings *CommandConfig)
{
memset(CommandConfig,0,sizeof(*CommandConfig));
/*
CommandConfig -> StartupMacro[0] = 0;
CommandConfig -> LogoffMacro[0] = 0;
CommandConfig -> LoginMacro[0] = 0;
CommandConfig -> UploadMacro[0] = 0;
CommandConfig -> DownloadMacro[0] = 0;
*/
}
STATIC VOID
ResetTransfer(struct TransferSettings *TransferConfig,STRPTR DefaultLib)
{
WORD i;
memset(TransferConfig,0,sizeof(*TransferConfig));
if(!DefaultLib)
strcpy(TransferConfig -> DefaultLibrary,"xprzmodem.library");
else
strcpy(TransferConfig -> DefaultLibrary,DefaultLib);
for(i = 0 ; i < strlen(TransferConfig -> DefaultLibrary) - 6 ; i++)
{
if(!Strnicmp(&TransferConfig -> DefaultLibrary[i],"zmodem",6))
{
strcpy(TransferConfig -> Signatures[TRANSFERSIG_DEFAULTUPLOAD] . Signature,"*\030B01");
TransferConfig -> Signatures[TRANSFERSIG_DEFAULTUPLOAD] . Length = strlen(TransferConfig -> Signatures[TRANSFERSIG_DEFAULTUPLOAD] . Signature);
break;
}
}
strcpy(TransferConfig -> ASCIIUploadLibrary, "xprascii.library");
strcpy(TransferConfig -> ASCIIDownloadLibrary, "xprascii.library");
TransferConfig -> TextUploadLibrary[0] = 0;
TransferConfig -> TextDownloadLibrary[0] = 0;
strcpy(TransferConfig -> BinaryUploadLibrary,"run hydracom device %p speed %b line %c nocarrier rec %> send %m");
strcpy(TransferConfig -> BinaryDownloadLibrary,"run hydracom device %p speed %b line %c nocarrier rec %> get");
TransferConfig -> InternalASCIIUpload = FALSE;
TransferConfig -> InternalASCIIDownload = FALSE;
TransferConfig -> QuietTransfer = FALSE;
TransferConfig -> MangleFileNames = FALSE;
TransferConfig -> LinePrompt[0] = 0;
TransferConfig -> SendTimeout = 0;
TransferConfig -> PacingMode = PACE_DIRECT;
TransferConfig -> StripBit8 = FALSE;
TransferConfig -> IgnoreDataPastArnold = TRUE;
TransferConfig -> TerminatorChar = 0x1A;
TransferConfig -> SendCR = EOL_CR;
TransferConfig -> SendLF = EOL_LF;
TransferConfig -> ReceiveCR = EOL_CR;
TransferConfig -> ReceiveLF = EOL_LF;
TransferConfig -> ErrorNotification = 20;
TransferConfig -> TransferNotification = XFERNOTIFY_ALWAYS;
TransferConfig -> DefaultType = XFER_XPR;
TransferConfig -> ASCIIDownloadType = XFER_XPR;
TransferConfig -> ASCIIUploadType = XFER_XPR;
TransferConfig -> TextDownloadType = XFER_DEFAULT;
TransferConfig -> TextUploadType = XFER_DEFAULT;
TransferConfig -> BinaryDownloadType = XFER_DEFAULT;
TransferConfig -> BinaryUploadType = XFER_DEFAULT;
memset(TransferConfig -> Signatures,0,sizeof(TransferConfig -> Signatures));
TransferConfig -> OverridePath = TRUE;
TransferConfig -> SetArchivedBit = FALSE;
TransferConfig -> IdentifyFiles = IDENTIFY_FILETYPE;
TransferConfig -> TransferIcons = FALSE;
TransferConfig -> PerfMeter = FALSE;
TransferConfig -> HideUploadIcon = FALSE;
}
/* ResetConfig():
*
* Initialize configuration with default values.
*/
VOID __regargs
ResetConfig(struct Configuration *Config,STRPTR PathBuffer)
{
if(!PathBuffer)
PathBuffer = "TERM:config";
ResetPath(Config -> PathConfig,PathBuffer);
ResetFile(Config -> FileConfig,PathBuffer);
ResetSerialConfig(Config -> SerialConfig);
ResetModem(Config -> ModemConfig);
ResetScreen(Config -> ScreenConfig);
ResetTerminal(Config -> TerminalConfig);
ResetEmulation(Config -> EmulationConfig);
ResetClip(Config -> ClipConfig);
ResetCapture(Config -> CaptureConfig);
ResetMisc(Config -> MiscConfig);
ResetCommand(Config -> CommandConfig);
ResetTransfer(Config -> TransferConfig,Config -> FileConfig ? Config -> FileConfig -> ProtocolFileName : (STRPTR)"xprzmodem.library");
ResetTranslationFile(Config -> TranslationFileName,PathBuffer);
ResetMacroFile(Config -> MacroFileName,PathBuffer);
ResetCursorFile(Config -> CursorFileName,PathBuffer);
ResetFastMacroFile(Config -> FastMacroFileName,PathBuffer);
}
VOID __regargs
DeleteConfigEntry(struct Configuration *Config,BYTE Type)
{
if(Type == PREF_ALL)
{
for(Type = PREF_SERIAL ; Type <= PREF_FASTMACROFILENAME ; Type++)
DeleteConfigEntry(Config,Type);
}
else
{
switch(Type)
{
case PREF_SERIAL:
if(Config -> SerialConfig)
{
FreeVecPooled(Config -> SerialConfig);
Config -> SerialConfig = NULL;
}
break;
case PREF_MODEM:
if(Config -> ModemConfig)
{
FreeVecPooled(Config -> ModemConfig);
Config -> ModemConfig = NULL;
}
break;
case PREF_COMMAND:
if(Config -> CommandConfig)
{
FreeVecPooled(Config -> CommandConfig);
Config -> CommandConfig = NULL;
}
break;
case PREF_SCREEN:
if(Config -> ScreenConfig)
{
FreeVecPooled(Config -> ScreenConfig);
Config -> ScreenConfig = NULL;
}
break;
case PREF_TERMINAL:
if(Config -> TerminalConfig)
{
FreeVecPooled(Config -> TerminalConfig);
Config -> TerminalConfig = NULL;
}
break;
case PREF_PATH:
if(Config -> PathConfig)
{
FreeVecPooled(Config -> PathConfig);
Config -> PathConfig = NULL;
}
break;
case PREF_MISC:
if(Config -> MiscConfig)
{
FreeVecPooled(Config -> MiscConfig);
Config -> MiscConfig = NULL;
}
break;
case PREF_CLIP:
if(Config -> ClipConfig)
{
FreeVecPooled(Config -> ClipConfig);
Config -> ClipConfig = NULL;
}
break;
case PREF_CAPTURE:
if(Config -> CaptureConfig)
{
FreeVecPooled(Config -> CaptureConfig);
Config -> CaptureConfig = NULL;
}
break;
case PREF_FILE:
if(Config -> FileConfig)
{
FreeVecPooled(Config -> FileConfig);
Config -> FileConfig = NULL;
}
break;
case PREF_EMULATION:
if(Config -> EmulationConfig)
{
FreeVecPooled(Config -> EmulationConfig);
Config -> EmulationConfig = NULL;
}
break;
case PREF_TRANSFER:
if(Config -> TransferConfig)
{
FreeVecPooled(Config -> TransferConfig);
Config -> TransferConfig = NULL;
}
break;
case PREF_TRANSLATIONFILENAME:
if(Config -> TranslationFileName)
{
FreeVecPooled(Config -> TranslationFileName);
Config -> TranslationFileName = NULL;
}
break;
case PREF_MACROFILENAME:
if(Config -> MacroFileName)
{
FreeVecPooled(Config -> MacroFileName);
Config -> MacroFileName = NULL;
}
break;
case PREF_CURSORFILENAME:
if(Config -> CursorFileName)
{
FreeVecPooled(Config -> CursorFileName);
Config -> CursorFileName = NULL;
}
break;
case PREF_FASTMACROFILENAME:
if(Config -> FastMacroFileName)
{
FreeVecPooled(Config -> FastMacroFileName);
Config -> FastMacroFileName = NULL;
}
break;
}
}
}
VOID __regargs
ResetConfigEntry(struct Configuration *Configuration,BYTE Type,BYTE Default)
{
if(Type == PREF_ALL)
{
for(Type = PREF_SERIAL ; Type <= PREF_FASTMACROFILENAME ; Type++)
ResetConfigEntry(Configuration,Type,Default);
}
else
{
switch(Type)
{
case PREF_SERIAL:
if(Default || !Config -> SerialConfig)
ResetSerialConfig(Configuration -> SerialConfig);
else
memcpy(Configuration -> SerialConfig,Config -> SerialConfig,sizeof(struct SerialSettings));
break;
case PREF_MODEM:
if(Default || !Config -> ModemConfig)
ResetModem(Configuration -> ModemConfig);
else
memcpy(Configuration -> ModemConfig,Config -> ModemConfig,sizeof(struct ModemSettings));
break;
case PREF_COMMAND:
if(Default || !Config -> CommandConfig)
ResetCommand(Configuration -> CommandConfig);
else
memcpy(Configuration -> CommandConfig,Config -> CommandConfig,sizeof(struct CommandSettings));
break;
case PREF_SCREEN:
if(Default || !Config -> ScreenConfig)
ResetScreen(Configuration -> ScreenConfig);
else
memcpy(Configuration -> ScreenConfig,Config -> ScreenConfig,sizeof(struct ScreenSettings));
FixScreenPens(Configuration -> ScreenConfig);
break;
case PREF_TERMINAL:
if(Default || !Config -> TerminalConfig)
ResetTerminal(Configuration -> TerminalConfig);
else
memcpy(Configuration -> TerminalConfig,Config -> TerminalConfig,sizeof(struct TerminalSettings));
break;
case PREF_PATH:
if(Default || !Config -> PathConfig)
ResetPath(Configuration -> PathConfig,NULL);
else
memcpy(Configuration -> PathConfig,Config -> PathConfig,sizeof(struct PathSettings));
break;
case PREF_MISC:
if(Default || !Config -> MiscConfig)
ResetMisc(Configuration -> MiscConfig);
else
memcpy(Configuration -> MiscConfig,Config -> MiscConfig,sizeof(struct MiscSettings));
break;
case PREF_CLIP:
if(Default || !Config -> ClipConfig)
ResetClip(Configuration -> ClipConfig);
else
memcpy(Configuration -> ClipConfig,Config -> ClipConfig,sizeof(struct ClipSettings));
break;
case PREF_CAPTURE:
if(Default || !Config -> CaptureConfig)
ResetCapture(Configuration -> CaptureConfig);
else
memcpy(Configuration -> CaptureConfig,Config -> CaptureConfig,sizeof(struct CaptureSettings));
break;
case PREF_FILE:
if(Default || !Config -> FileConfig)
ResetFile(Configuration -> FileConfig,NULL);
else
{
if(Configuration -> FileConfig && Config -> FileConfig)
memcpy(Configuration -> FileConfig,Config -> FileConfig,sizeof(struct FileSettings));
}
break;
case PREF_EMULATION:
if(Default || !Config -> EmulationConfig)
ResetEmulation(Configuration -> EmulationConfig);
else
memcpy(Configuration -> EmulationConfig,Config -> EmulationConfig,sizeof(struct EmulationSettings));
break;
case PREF_TRANSFER:
if(Default || !Config -> TransferConfig)
ResetTransfer(Configuration -> TransferConfig,Config -> FileConfig -> ProtocolFileName);
else
memcpy(Configuration -> TransferConfig,Config -> TransferConfig,sizeof(struct TransferSettings));
break;
case PREF_TRANSLATIONFILENAME:
if(Default || !Config -> TranslationFileName)
ResetTranslationFile(Configuration -> TranslationFileName,NULL);
else
strcpy(Configuration -> TranslationFileName,Config -> TranslationFileName);
break;
case PREF_MACROFILENAME:
if(Default || !Config -> MacroFileName)
ResetMacroFile(Configuration -> MacroFileName,NULL);
else
strcpy(Configuration -> MacroFileName,Config -> MacroFileName);
break;
case PREF_CURSORFILENAME:
if(Default || !Config -> CursorFileName)
ResetMacroFile(Configuration -> CursorFileName,NULL);
else
strcpy(Configuration -> CursorFileName,Config -> CursorFileName);
break;
case PREF_FASTMACROFILENAME:
if(Default || !Config -> FastMacroFileName)
ResetMacroFile(Configuration -> FastMacroFileName,NULL);
else
strcpy(Configuration -> FastMacroFileName,Config -> FastMacroFileName);
break;
}
}
}
APTR __regargs
GetConfigEntry(struct Configuration *Config,BYTE Type)
{
switch(Type)
{
case PREF_SERIAL:
return(Config -> SerialConfig);
case PREF_MODEM:
return(Config -> ModemConfig);
case PREF_COMMAND:
return(Config -> CommandConfig);
case PREF_SCREEN:
return(Config -> ScreenConfig);
case PREF_TERMINAL:
return(Config -> TerminalConfig);
case PREF_PATH:
return(Config -> PathConfig);
case PREF_MISC:
return(Config -> MiscConfig);
case PREF_CLIP:
return(Config -> ClipConfig);
case PREF_CAPTURE:
return(Config -> CaptureConfig);
case PREF_FILE:
return(Config -> FileConfig);
case PREF_EMULATION:
return(Config -> EmulationConfig);
case PREF_TRANSFER:
return(Config -> TransferConfig);
case PREF_TRANSLATIONFILENAME:
return(Config -> TranslationFileName);
case PREF_MACROFILENAME:
return(Config -> MacroFileName);
case PREF_CURSORFILENAME:
return(Config -> CursorFileName);
case PREF_FASTMACROFILENAME:
return(Config -> FastMacroFileName);
default:
return(NULL);
}
}
BYTE __regargs
CreateConfigEntry(struct Configuration *Config,BYTE Type)
{
if(Type == PREF_ALL)
{
for(Type = PREF_SERIAL ; Type <= PREF_FASTMACROFILENAME ; Type++)
{
if(!CreateConfigEntry(Config,Type))
{
DeleteConfigEntry(Config,PREF_ALL);
return(FALSE);
}
}
return(TRUE);
}
else
{
APTR Data;
switch(Type)
{
case PREF_SERIAL:
Data = Config -> SerialConfig;
break;
case PREF_MODEM:
Data = Config -> ModemConfig;
break;
case PREF_COMMAND:
Data = Config -> CommandConfig;
break;
case PREF_SCREEN:
Data = Config -> ScreenConfig;
break;
case PREF_TERMINAL:
Data = Config -> TerminalConfig;
break;
case PREF_PATH:
Data = Config -> PathConfig;
break;
case PREF_MISC:
Data = Config -> MiscConfig;
break;
case PREF_CLIP:
Data = Config -> ClipConfig;
break;
case PREF_CAPTURE:
Data = Config -> CaptureConfig;
break;
case PREF_FILE:
Data = Config -> FileConfig;
break;
case PREF_EMULATION:
Data = Config -> EmulationConfig;
break;
case PREF_TRANSFER:
Data = Config -> TransferConfig;
break;
case PREF_TRANSLATIONFILENAME:
Data = Config -> TranslationFileName;
break;
case PREF_MACROFILENAME:
Data = Config -> MacroFileName;
break;
case PREF_CURSORFILENAME:
Data = Config -> CursorFileName;
break;
case PREF_FASTMACROFILENAME:
Data = Config -> FastMacroFileName;
break;
default:
return(FALSE);
}
if(!Data)
{
if(Data = AllocVecPooled(SizeTable[Type - 1],MEMF_ANY | MEMF_CLEAR))
{
(*ResetTable[Type - 1])(Data,NULL);
switch(Type)
{
case PREF_SERIAL:
Config -> SerialConfig = Data;
break;
case PREF_MODEM:
Config -> ModemConfig = Data;
break;
case PREF_COMMAND:
Config -> CommandConfig = Data;
break;
case PREF_SCREEN:
Config -> ScreenConfig = Data;
break;
case PREF_TERMINAL:
Config -> TerminalConfig = Data;
break;
case PREF_PATH:
Config -> PathConfig = Data;
break;
case PREF_MISC:
Config -> MiscConfig = Data;
break;
case PREF_CLIP:
Config -> ClipConfig = Data;
break;
case PREF_CAPTURE:
Config -> CaptureConfig = Data;
break;
case PREF_FILE:
Config -> FileConfig = Data;
break;
case PREF_EMULATION:
Config -> EmulationConfig = Data;
break;
case PREF_TRANSFER:
Config -> TransferConfig = Data;
break;
case PREF_TRANSLATIONFILENAME:
Config -> TranslationFileName = Data;
break;
case PREF_MACROFILENAME:
Config -> MacroFileName = Data;
break;
case PREF_CURSORFILENAME:
Config -> CursorFileName = Data;
break;
case PREF_FASTMACROFILENAME:
Config -> FastMacroFileName = Data;
break;
}
return(TRUE);
}
else
return(FALSE);
}
else
return(TRUE);
}
}
VOID __regargs
DeleteConfiguration(struct Configuration *Config)
{
if(Config)
{
DeleteConfigEntry(Config,PREF_ALL);
FreeVecPooled(Config);
}
}
struct Configuration * __regargs
CreateConfiguration(BYTE Fill)
{
struct Configuration *Config;
if(Config = (struct Configuration *)AllocVecPooled(sizeof(struct Configuration),MEMF_ANY | MEMF_CLEAR))
{
if(Fill)
{
if(!CreateConfigEntry(Config,PREF_ALL))
{
FreeVecPooled(Config);
return(NULL);
}
}
return(Config);
}
else
return(NULL);
}
STATIC BYTE
WriteConfigChunk(struct IFFHandle *Handle,struct Configuration *Config,BYTE Type,APTR TempBuffer,STRPTR Password)
{
APTR Data;
switch(Type)
{
case PREF_SERIAL:
Data = Config -> SerialConfig;
break;
case PREF_MODEM:
Data = Config -> ModemConfig;
break;
case PREF_COMMAND:
Data = Config -> CommandConfig;
break;
case PREF_SCREEN:
Data = Config -> ScreenConfig;
break;
case PREF_TERMINAL:
Data = Config -> TerminalConfig;
break;
case PREF_PATH:
Data = Config -> PathConfig;
break;
case PREF_MISC:
Data = Config -> MiscConfig;
break;
case PREF_CLIP:
Data = Config -> ClipConfig;
break;
case PREF_CAPTURE:
Data = Config -> CaptureConfig;
break;
// OBSOLETE!
case PREF_FILE:
return(TRUE);
// Data = Config -> FileConfig;
// break;
case PREF_EMULATION:
Data = Config -> EmulationConfig;
break;
case PREF_TRANSFER:
Data = Config -> TransferConfig;
break;
case PREF_TRANSLATIONFILENAME:
Data = Config -> TranslationFileName;
break;
case PREF_MACROFILENAME:
Data = Config -> MacroFileName;
break;
case PREF_CURSORFILENAME:
Data = Config -> CursorFileName;
break;
case PREF_FASTMACROFILENAME:
Data = Config -> FastMacroFileName;
break;
default:
Data = NULL;
break;
}
if(Data)
{
if(TempBuffer)
{
Encrypt(Data,SizeTable[Type - 1],TempBuffer,Password,20);
Data = TempBuffer;
}
if(!PushChunk(Handle,0,TypeTable[Type - 1],SizeTable[Type - 1]))
{
if(WriteChunkRecords(Handle,Data,SizeTable[Type - 1],1) == 1)
{
if(!PopChunk(Handle))
return(TRUE);
}
}
return(FALSE);
}
else
return(TRUE);
}
STATIC UBYTE
IsConfigChunk(ULONG ID)
{
UBYTE Type;
for(Type = PREF_SERIAL ; Type <= PREF_FASTMACROFILENAME ; Type++)
{
if(ID == TypeTable[Type - 1])
return(Type);
}
return(0);
}
STATIC BYTE
WriteConfigChunks(struct IFFHandle *Handle,struct Configuration *Config,APTR TempBuffer,STRPTR Password)
{
UBYTE Type;
for(Type = PREF_SERIAL ; Type <= PREF_FASTMACROFILENAME ; Type++)
{
if(!WriteConfigChunk(Handle,Config,Type,TempBuffer,Password))
return(FALSE);
}
return(TRUE);
}
VOID __regargs
SaveConfig(const struct Configuration *Src,struct Configuration *Dst)
{
if(Dst -> SerialConfig && Src -> SerialConfig)
memcpy(Dst -> SerialConfig,Src -> SerialConfig,sizeof(struct SerialSettings));
if(Dst -> ModemConfig && Src -> ModemConfig)
memcpy(Dst -> ModemConfig,Src -> ModemConfig,sizeof(struct ModemSettings));
if(Dst -> ScreenConfig && Src -> ScreenConfig)
{
memcpy(Dst -> ScreenConfig,Src -> ScreenConfig,sizeof(struct ScreenSettings));
FixScreenPens(Dst -> ScreenConfig);
}
if(Dst -> TerminalConfig && Src -> TerminalConfig)
memcpy(Dst -> TerminalConfig,Src -> TerminalConfig,sizeof(struct TerminalSettings));
if(Dst -> EmulationConfig && Src -> EmulationConfig)
memcpy(Dst -> EmulationConfig,Src -> EmulationConfig,sizeof(struct EmulationSettings));
if(Dst -> ClipConfig && Src -> ClipConfig)
memcpy(Dst -> ClipConfig,Src -> ClipConfig,sizeof(struct ClipSettings));
if(Dst -> CaptureConfig && Src -> CaptureConfig)
memcpy(Dst -> CaptureConfig,Src -> CaptureConfig,sizeof(struct CaptureSettings));
if(Dst -> CommandConfig && Src -> CommandConfig)
memcpy(Dst -> CommandConfig,Src -> CommandConfig,sizeof(struct CommandSettings));
if(Dst -> MiscConfig && Src -> MiscConfig)
memcpy(Dst -> MiscConfig,Src -> MiscConfig,sizeof(struct MiscSettings));
if(Dst -> PathConfig && Src -> PathConfig)
memcpy(Dst -> PathConfig,Src -> PathConfig,sizeof(struct PathSettings));
if(Dst -> FileConfig && Src -> FileConfig)
memcpy(Dst -> FileConfig,Src -> FileConfig,sizeof(struct FileSettings));
if(Dst -> TransferConfig && Src -> TransferConfig)
memcpy(Dst -> TransferConfig,Src -> TransferConfig,sizeof(struct TransferSettings));
if(Dst -> TranslationFileName && Src -> TranslationFileName)
strcpy(Dst -> TranslationFileName,Src -> TranslationFileName);
if(Dst -> MacroFileName && Src -> MacroFileName)
strcpy(Dst -> MacroFileName,Src -> MacroFileName);
if(Dst -> CursorFileName && Src -> CursorFileName)
strcpy(Dst -> CursorFileName,Src -> CursorFileName);
if(Dst -> FastMacroFileName && Src -> FastMacroFileName)
strcpy(Dst -> FastMacroFileName,Src -> FastMacroFileName);
}
VOID __regargs
UpdateConfig(const struct Configuration *Src,struct Configuration *Dst)
{
if(Src -> SerialConfig)
memcpy(Dst -> SerialConfig,Src -> SerialConfig,sizeof(struct SerialSettings));
if(Src -> ModemConfig)
memcpy(Dst -> ModemConfig,Src -> ModemConfig,sizeof(struct ModemSettings));
if(Src -> ScreenConfig)
{
memcpy(Dst -> ScreenConfig,Src -> ScreenConfig,sizeof(struct ScreenSettings));
FixScreenPens(Dst -> ScreenConfig);
}
if(Src -> TerminalConfig)
memcpy(Dst -> TerminalConfig,Src -> TerminalConfig,sizeof(struct TerminalSettings));
if(Src -> EmulationConfig)
memcpy(Dst -> EmulationConfig,Src -> EmulationConfig,sizeof(struct EmulationSettings));
if(Src -> ClipConfig)
memcpy(Dst -> ClipConfig,Src -> ClipConfig,sizeof(struct ClipSettings));
if(Src -> CaptureConfig)
memcpy(Dst -> CaptureConfig,Src -> CaptureConfig,sizeof(struct CaptureSettings));
if(Src -> CommandConfig)
memcpy(Dst -> CommandConfig,Src -> CommandConfig,sizeof(struct CommandSettings));
if(Src -> MiscConfig)
memcpy(Dst -> MiscConfig,Src -> MiscConfig,sizeof(struct MiscSettings));
if(Src -> PathConfig)
memcpy(Dst -> PathConfig,Src -> PathConfig,sizeof(struct PathSettings));
if(Src -> FileConfig && Dst -> FileConfig)
memcpy(Dst -> FileConfig,Src -> FileConfig,sizeof(struct FileSettings));
if(Src -> TransferConfig)
memcpy(Dst -> TransferConfig,Src -> TransferConfig,sizeof(struct TransferSettings));
if(Src -> TranslationFileName)
strcpy(Dst -> TranslationFileName,Src -> TranslationFileName);
if(Src -> MacroFileName)
strcpy(Dst -> MacroFileName,Src -> MacroFileName);
if(Src -> CursorFileName)
strcpy(Dst -> CursorFileName,Src -> CursorFileName);
if(Src -> FastMacroFileName)
strcpy(Dst -> FastMacroFileName,Src -> FastMacroFileName);
}
VOID __regargs
SwapConfig(struct Configuration *Src,struct Configuration *Dst)
{
if(Dst -> SerialConfig && Src -> SerialConfig)
swmem(Dst -> SerialConfig,Src -> SerialConfig,sizeof(struct SerialSettings));
if(Dst -> ModemConfig && Src -> ModemConfig)
swmem(Dst -> ModemConfig,Src -> ModemConfig,sizeof(struct ModemSettings));
if(Dst -> ScreenConfig && Src -> ScreenConfig)
swmem(Dst -> ScreenConfig,Src -> ScreenConfig,sizeof(struct ScreenSettings));
if(Dst -> TerminalConfig && Src -> TerminalConfig)
swmem(Dst -> TerminalConfig,Src -> TerminalConfig,sizeof(struct TerminalSettings));
if(Dst -> EmulationConfig && Src -> EmulationConfig)
swmem(Dst -> EmulationConfig,Src -> EmulationConfig,sizeof(struct EmulationSettings));
if(Dst -> ClipConfig && Src -> ClipConfig)
swmem(Dst -> ClipConfig,Src -> ClipConfig,sizeof(struct ClipSettings));
if(Dst -> CaptureConfig && Src -> CaptureConfig)
swmem(Dst -> CaptureConfig,Src -> CaptureConfig,sizeof(struct CaptureSettings));
if(Dst -> CommandConfig && Src -> CommandConfig)
swmem(Dst -> CommandConfig,Src -> CommandConfig,sizeof(struct CommandSettings));
if(Dst -> MiscConfig && Src -> MiscConfig)
swmem(Dst -> MiscConfig,Src -> MiscConfig,sizeof(struct MiscSettings));
if(Dst -> PathConfig && Src -> PathConfig)
swmem(Dst -> PathConfig,Src -> PathConfig,sizeof(struct PathSettings));
if(Dst -> TransferConfig && Src -> TransferConfig)
swmem(Dst -> TransferConfig,Src -> TransferConfig,sizeof(struct TransferSettings));
if(Dst -> FileConfig && Src -> FileConfig)
swmem(Dst -> FileConfig,Src -> FileConfig,sizeof(struct FileSettings));
if(Dst -> TranslationFileName && Src -> TranslationFileName)
swmem(Dst -> TranslationFileName,Src -> TranslationFileName,MAX_FILENAME_LENGTH);
if(Dst -> MacroFileName && Src -> MacroFileName)
swmem(Dst -> MacroFileName,Src -> MacroFileName,MAX_FILENAME_LENGTH);
if(Dst -> CursorFileName && Src -> CursorFileName)
swmem(Dst -> CursorFileName,Src -> CursorFileName,MAX_FILENAME_LENGTH);
if(Dst -> FastMacroFileName && Src -> FastMacroFileName)
swmem(Dst -> FastMacroFileName,Src -> FastMacroFileName,MAX_FILENAME_LENGTH);
}
/* SavePhonebook(STRPTR Name):
*
* Save the current phone book to a disk file.
*/
BYTE __regargs
SavePhonebook(STRPTR Name)
{
struct IFFHandle *Handle;
BYTE Success = FALSE;
LONG Error = 0;
if(Phonebook && NumPhoneEntries)
{
if(Handle = (struct IFFHandle *)AllocIFF())
{
if(Handle -> iff_Stream = Open(Name,MODE_NEWFILE))
{
InitIFFasDOS(Handle);
if(!(Error = OpenIFF(Handle,IFFF_WRITE)))
{
if(!(Error = PushChunk(Handle,ID_TERM,ID_CAT,IFFSIZE_UNKNOWN)))
{
if(!(Error = PushChunk(Handle,ID_TERM,ID_FORM,IFFSIZE_UNKNOWN)))
{
if(!(Error = PushChunk(Handle,0,ID_VERS,IFFSIZE_UNKNOWN)))
{
struct TermInfo TermInfo;
TermInfo . Version = CONFIG_FILE_VERSION;
TermInfo . Revision = CONFIG_FILE_REVISION;
if(WriteChunkRecords(Handle,&TermInfo,sizeof(struct TermInfo),1) == 1)
{
if(!(Error = PopChunk(Handle)))
{
STRPTR TempBuffer = NULL;
if(PhonePasswordUsed)
{
if(!(Error = PushChunk(Handle,0,ID_PSWD,20)))
{
Success = TRUE;
if(WriteChunkBytes(Handle,PhonePassword,20) != 20)
Success = FALSE;
if(PopChunk(Handle))
Success = FALSE;
if(Success)
{
LONG Max = sizeof(struct PhoneHeader),Type;
for(Type = PREF_SERIAL ; Type <= PREF_FASTMACROFILENAME ; Type++)
{
if(SizeTable[Type - 1] > Max)
Max = SizeTable[Type - 1];
}
if(!(TempBuffer = AllocVecPooled(Max,MEMF_ANY)))
{
Error = ERR_NO_MEM;
Success = FALSE;
}
}
}
}
else
Success = TRUE;
if(Success)
{
Success = FALSE;
if(!(Error = PushChunk(Handle,0,ID_DIAL,IFFSIZE_UNKNOWN)))
{
PhonebookGlobals Globals;
Globals . Count = NumPhoneEntries;
Globals . ID = PhonebookID;
Globals . DefaultGroup = PhonebookDefaultGroup;
Globals . AutoDial = PhonebookAutoDial;
Globals . AutoExit = PhonebookAutoExit;
if(WriteChunkBytes(Handle,&Globals,sizeof(Globals)) == sizeof(Globals))
{
if(!(Error = PopChunk(Handle)))
{
if(!(Error = PopChunk(Handle)))
{
LONG i;
Success = TRUE;
for(i = 0 ; Success && i < NumPhoneEntries ; i++)
{
Success = FALSE;
if(!(Error = PushChunk(Handle,ID_TERM,ID_FORM,IFFSIZE_UNKNOWN)))
{
if(!(Error = PushChunk(Handle,0,ID_PHON,sizeof(struct PhoneHeader))))
{
if(TempBuffer)
{
Encrypt((UBYTE *)Phonebook[i] -> Header,sizeof(struct PhoneHeader),TempBuffer,PhonePassword,20);
if(WriteChunkRecords(Handle,TempBuffer,sizeof(struct PhoneHeader),1) == 1)
{
if(!(Error = PopChunk(Handle)))
{
if(WriteConfigChunks(Handle,Phonebook[i] -> Config,TempBuffer,PhonePassword))
{
Success = TRUE;
if(!Phonebook[i] -> Header -> NoRates)
{
struct TimeDateNode *TimeDateNode;
TimeDateNode = (struct TimeDateNode *)Phonebook[i] -> TimeDateList . mlh_Head;
while(TimeDateNode -> VanillaNode . ln_Succ)
{
if(!(Error = PushChunk(Handle,0,ID_DATE,IFFSIZE_UNKNOWN)))
{
if(WriteChunkBytes(Handle,&TimeDateNode -> Header,sizeof(struct TimeDateHeader)) != sizeof(struct TimeDateHeader))
{
Error = IoErr();
Success = FALSE;
break;
}
else
{
if(WriteChunkBytes(Handle,TimeDateNode -> Table,TimeDateNode -> Table[0] . Count * sizeof(struct TimeDate)) != TimeDateNode -> Table[0] . Count * sizeof(struct TimeDate))
{
Error = IoErr();
Success = FALSE;
break;
}
}
if(Success)
{
if(Error = PopChunk(Handle))
{
Success = FALSE;
break;
}
}
TimeDateNode = (struct TimeDateNode *)TimeDateNode -> VanillaNode . ln_Succ;
}
}
}
}
else
{
Error = IoErr();
Success = FALSE;
}
}
}
else
Error = IoErr();
}
else
{
if(WriteChunkRecords(Handle,Phonebook[i] -> Header,sizeof(struct PhoneHeader),1) == 1)
{
if(!(Error = PopChunk(Handle)))
{
if(WriteConfigChunks(Handle,Phonebook[i] -> Config,NULL,NULL))
{
Success = TRUE;
if(!Phonebook[i] -> Header -> NoRates)
{
struct TimeDateNode *TimeDateNode;
TimeDateNode = (struct TimeDateNode *)Phonebook[i] -> TimeDateList . mlh_Head;
while(TimeDateNode -> VanillaNode . ln_Succ)
{
if(!(Error = PushChunk(Handle,0,ID_DATE,IFFSIZE_UNKNOWN)))
{
if(WriteChunkBytes(Handle,&TimeDateNode -> Header,sizeof(struct TimeDateHeader)) != sizeof(struct TimeDateHeader))
{
Error = IoErr();
Success = FALSE;
break;
}
else
{
if(WriteChunkBytes(Handle,TimeDateNode -> Table,TimeDateNode -> Table[0] . Count * sizeof(struct TimeDate)) != TimeDateNode -> Table[0] . Count * sizeof(struct TimeDate))
{
Error = IoErr();
Success = FALSE;
break;
}
}
if(Success)
{
if(Error = PopChunk(Handle))
{
Success = FALSE;
break;
}
}
TimeDateNode = (struct TimeDateNode *)TimeDateNode -> VanillaNode . ln_Succ;
}
}
}
}
else
{
Success = FALSE;
Error = IoErr();
}
}
}
else
Error = IoErr();
}
}
if(Success)
{
if(Error = PopChunk(Handle))
Success = FALSE;
}
}
}
// Now for the groups
if(Success && PhoneGroupList . mlh_Head -> mln_Succ)
{
struct PhoneGroupNode *GroupNode;
struct PhoneNode *Node;
PhoneGroupHeader Header;
BOOL GotData = FALSE;
// So the extension stuff is set to zero
memset(&Header,0,sizeof(Header));
// Run down the groups
for(GroupNode = (PhoneGroupNode *)PhoneGroupList . mlh_Head ; Success && GroupNode -> Node . ln_Succ ; GroupNode = (PhoneGroupNode *)GroupNode -> Node . ln_Succ)
{
// Count the members
Header . Count = 0;
for(Node = (struct PhoneNode *)GroupNode -> GroupList . mlh_Head ; Node -> VanillaNode . ln_Succ ; Node = (struct PhoneNode *)Node -> VanillaNode . ln_Succ)
Header . Count++;
// Open the group
if(Header . Count)
{
if(!GotData)
{
if(!(Error = PushChunk(Handle,ID_TERM,ID_FORM,IFFSIZE_UNKNOWN)))
GotData = TRUE;
}
// Pick up the group name
strcpy(Header . FullName,GroupNode -> LocalName);
if(!Error)
Error = PushChunk(Handle,0,ID_GRUP,sizeof(Header) + sizeof(LONG) * Header . Count);
if(!Error)
{
// First the header...
if(WriteChunkBytes(Handle,&Header,sizeof(Header)) == sizeof(Header))
{
// ...then the IDs of the group members
for(Node = (struct PhoneNode *)GroupNode -> GroupList . mlh_Head ; Node -> VanillaNode . ln_Succ ; Node = (struct PhoneNode *)Node -> VanillaNode . ln_Succ)
{
if(WriteChunkBytes(Handle,&Node -> Entry -> Header -> ID,sizeof(ULONG)) != sizeof(ULONG))
{
Success = FALSE;
break;
}
}
if(!Success)
{
Error = IoErr();
break;
}
}
else
{
Error = IoErr();
Success = FALSE;
break;
}
if(Error = PopChunk(Handle))
Success = FALSE;
}
else
Success = FALSE;
}
}
if(Success && GotData)
{
if(Error = PopChunk(Handle))
Success = FALSE;
}
}
}
}
}
else
Error = IoErr();
}
}
if(TempBuffer)
FreeVecPooled(TempBuffer);
}
}
else
Error = IoErr();
}
}
if(Success)
{
if(Error = PopChunk(Handle))
Success = FALSE;
}
}
CloseIFF(Handle);
}
Close(Handle -> iff_Stream);
}
else
Error = IoErr();
FreeIFF(Handle);
}
else
Error = ERR_NO_MEM;
if(Success)
AddProtection(Name,FIBF_EXECUTE);
else
DeleteFile(Name);
}
if(Error)
SetIoErr(Error);
return(Success);
}
STATIC BYTE
ReadConfigChunk(struct IFFHandle *Handle,struct Configuration *Config,UBYTE Type,LONG Len,STRPTR Password)
{
if(CreateConfigEntry(Config,Type))
{
APTR Data;
switch(Type)
{
case PREF_SERIAL:
Data = Config -> SerialConfig;
break;
case PREF_MODEM:
Data = Config -> ModemConfig;
break;
case PREF_COMMAND:
Data = Config -> CommandConfig;
break;
case PREF_SCREEN:
Data = Config -> ScreenConfig;
break;
case PREF_TERMINAL:
Data = Config -> TerminalConfig;
break;
case PREF_PATH:
Data = Config -> PathConfig;
break;
case PREF_MISC:
Data = Config -> MiscConfig;
break;
case PREF_CLIP:
Data = Config -> ClipConfig;
break;
case PREF_CAPTURE:
Data = Config -> CaptureConfig;
break;
case PREF_FILE:
Data = Config -> FileConfig;
break;
case PREF_EMULATION:
Data = Config -> EmulationConfig;
break;
case PREF_TRANSFER:
Data = Config -> TransferConfig;
break;
case PREF_TRANSLATIONFILENAME:
Data = Config -> TranslationFileName;
break;
case PREF_MACROFILENAME:
Data = Config -> MacroFileName;
break;
case PREF_CURSORFILENAME:
Data = Config -> CursorFileName;
break;
case PREF_FASTMACROFILENAME:
Data = Config -> FastMacroFileName;
break;
}
Len = MIN(SizeTable[Type - 1],Len);
if(ReadChunkBytes(Handle,Data,Len) == Len)
{
if(Password)
Decrypt(Data,Len,Data,Password,20);
if(Type == PREF_SCREEN)
FixScreenPens(Data);
return(TRUE);
}
}
return(FALSE);
}
/* LoadPhonebook(STRPTR Name):
*
* Restore a phone book from a disk file.
*/
BYTE __regargs
LoadPhonebook(STRPTR Name,PhonebookHandle *BookHandle)
{
struct PhoneEntry **PrivatePhonebook;
LONG PrivatePhoneSize = 0,
CurrentPhoneSize = 0,
Count = 0,
Index = 0;
BYTE Success = FALSE,
LastHadTime = TRUE,
UsePhonePassword = FALSE,
FirstChunk = TRUE,
UseOld = FALSE;
struct IFFHandle *Handle;
struct ContextNode *Chunk;
struct TimeDateNode *TimeDateNode;
UBYTE ConfigChunkType,
PasswordBuffer[20];
BYTE CheckedChunk = FALSE;
LONG Error = 0;
PhonebookGlobals Globals;
struct timeval Now;
ULONG PrivatePhonebookID;
struct MinList LocalPhoneGroupList;
BOOL GotID = FALSE;
NewList((struct List *)&LocalPhoneGroupList);
GetSysTime(&Now);
memset(&Globals,0,sizeof(Globals));
Globals . ID = Now . tv_secs;
Globals . DefaultGroup = 0;
Globals . AutoDial = 0;
Globals . AutoExit = 0;
if(Handle = AllocIFF())
{
if(Handle -> iff_Stream = Open(Name,MODE_OLDFILE))
{
InitIFFasDOS(Handle);
if(!(Error = OpenIFF(Handle,IFFF_READ)))
{
if(!(Error = StopChunks(Handle,Stops,NUM_STOPS)))
{
struct TermInfo TermInfo;
while(!ParseIFF(Handle,IFFPARSE_SCAN))
{
Chunk = CurrentChunk(Handle);
/* Is this the first chunk to be read? */
if(!CheckedChunk)
{
/* The first chunk must be a
* catalog chunk, or this is
* not a proper phonebook file.
*/
if(Chunk -> cn_ID != ID_CAT)
break;
else
CheckedChunk = TRUE;
}
if(Chunk -> cn_ID == ID_VERS)
{
if(ReadChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
{
if(TermInfo . Version != CONFIG_FILE_VERSION || (TermInfo . Version == CONFIG_FILE_VERSION && TermInfo . Revision > CONFIG_FILE_REVISION))
{
if(TermInfo . Version == 2 && TermInfo . Revision == 4)
UseOld = TRUE;
if(TermInfo . Version != 3)
break;
}
}
else
{
Error = IoErr();
break;
}
}
if(Chunk -> cn_ID == ID_PSWD)
{
if(ReadChunkBytes(Handle,PasswordBuffer,20) == 20)
{
if(BookHandle)
{
if(BookHandle -> PhonePasswordUsed)
{
if(!memcmp(BookHandle -> PhonePassword,PasswordBuffer,20))
{
UsePhonePassword = TRUE;
continue;
}
}
}
else
{
if(PhonePasswordUsed)
{
if(!memcmp(PhonePassword,PasswordBuffer,20))
{
UsePhonePassword = TRUE;
continue;
}
}
}
memset(SharedBuffer,0,21);
if(GetString(FALSE,TRUE,21,LocaleString(MSG_PHONEPANEL_PLEASE_ENTER_PASSWORD_TXT),SharedBuffer))
{
UBYTE AnotherBuffer[20];
Encrypt(SharedBuffer,20,AnotherBuffer,SharedBuffer,strlen(SharedBuffer));
if(!memcmp(PasswordBuffer,AnotherBuffer,20))
{
UsePhonePassword = TRUE;
continue;
}
else
{
MyEasyRequest(Window,LocaleString(MSG_TERMPHONE_WRONG_PASSWORD_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT),Name);
break;
}
}
else
break;
}
else
{
Error = IoErr();
break;
}
}
if(Chunk -> cn_ID == ID_DIAL)
{
WORD Size = MIN(sizeof(PhonebookGlobals),Chunk -> cn_Size);
if(ReadChunkBytes(Handle,&Globals,Size) == Size)
{
CurrentPhoneSize = Globals . Count;
if(Size >= sizeof(PhonebookGlobals))
GotID = TRUE;
PrivatePhonebookID = Globals . ID;
if(!CurrentPhoneSize)
break;
else
{
if(!(PrivatePhonebook = CreatePhonebook(CurrentPhoneSize,&PrivatePhoneSize,TRUE)))
{
Error = ERR_NO_MEM;
break;
}
}
}
else
{
Error = IoErr();
break;
}
}
if(Chunk -> cn_ID == ID_PHON)
{
WORD Size = MIN(sizeof(struct PhoneHeader),Chunk -> cn_Size);
if(!CurrentPhoneSize)
break;
if(!LastHadTime)
{
if(TimeDateNode = CreateTimeDateNode(-1,-1,"",2))
AddTail((struct List *)&PrivatePhonebook[Index] -> TimeDateList,&TimeDateNode -> VanillaNode);
}
if(!FirstChunk)
Index++;
else
FirstChunk = FALSE;
memset(PrivatePhonebook[Index] -> Header,0,sizeof(struct PhoneHeader));
if(ReadChunkBytes(Handle,PrivatePhonebook[Index] -> Header,Size) == Size)
{
if(UsePhonePassword)
Decrypt((UBYTE *)PrivatePhonebook[Index] -> Header,Size,(UBYTE *)PrivatePhonebook[Index] -> Header,PasswordBuffer,20);
PrivatePhonebook[Index] -> Count = -1;
if(!GotID)
PrivatePhonebook[Index] -> Header -> ID = PrivatePhonebookID++;
LastHadTime = FALSE;
Count++;
}
else
{
Error = IoErr();
break;
}
}
// Mucho importante -- must follow the phonebook entries
if(Chunk -> cn_ID == ID_GRUP)
{
PhoneGroupHeader Header;
struct MinList *GroupList;
DB(kprintf("--> ID_GRUP\n"));
if(BookHandle)
GroupList = BookHandle -> PhoneGroupList;
else
GroupList = &LocalPhoneGroupList;
if(GroupList)
{
if(ReadChunkBytes(Handle,&Header,sizeof(Header)) == sizeof(Header))
{
PhoneGroupNode *GroupNode;
ULONG ID;
LONG i;
GroupNode = NULL;
Success = TRUE;
DB(kprintf("group name |%s| entries %ld\n",Header . FullName,Header . Count));
for(i = 0 ; Success && i < Header . Count ; i++)
{
if(ReadChunkBytes(Handle,&ID,sizeof(ULONG)) == sizeof(ULONG))
{
struct PhoneNode *Node;
LONG j;
DB(kprintf("looking for 0x%08lx\n",ID));
for(j = 0 ; j < CurrentPhoneSize ; j++)
{
if(PrivatePhonebook[j] -> Header -> ID == ID)
{
DB(kprintf("found it |%s|\n",PrivatePhonebook[j] -> Header -> Name));
if(!GroupNode)
{
if(!(GroupNode = (PhoneGroupNode *)AllocVecPooled(sizeof(PhoneGroupNode),MEMF_ANY | MEMF_CLEAR)))
{
Error = ERROR_NO_FREE_STORE;
Success = FALSE;
break;
}
strcpy(GroupNode -> LocalName,Header . FullName);
GroupNode -> Node . ln_Name = GroupNode -> LocalName;
NewList((struct List *)&GroupNode -> GroupList);
AddTail((struct List *)&LocalPhoneGroupList,(struct Node *)GroupNode);
}
if(Node = (struct PhoneNode *)AllocVecPooled(sizeof(struct PhoneNode),MEMF_ANY | MEMF_CLEAR))
{
PrivatePhonebook[j] -> ThisGroup = GroupNode;
PrivatePhonebook[j] -> NodeGroup = Node;
Node -> VanillaNode . ln_Name = Node -> LocalName;
Node -> Entry = PrivatePhonebook[j];
SPrintf(Node -> LocalName," %s",PrivatePhonebook[j] -> Header -> Name);
AddTail((struct List *)&GroupNode -> GroupList,(struct Node *)Node);
}
else
{
Error = ERROR_NO_FREE_STORE;
Success = FALSE;
break;
}
}
}
}
else
{
Error = IoErr();
Success = FALSE;
break;
}
}
}
else
{
Error = IoErr();
Success = FALSE;
}
}
if(!Success)
break;
}
if(ConfigChunkType = IsConfigChunk(Chunk -> cn_ID))
{
if(!CurrentPhoneSize)
break;
if(UsePhonePassword)
{
if(!ReadConfigChunk(Handle,PrivatePhonebook[Index] -> Config,ConfigChunkType,Chunk -> cn_Size,PasswordBuffer))
{
if(Count)
CurrentPhoneSize = Count - 1;
else
CurrentPhoneSize = 0;
break;
}
else
FixOldConfig(PrivatePhonebook[Index] -> Config,ConfigChunkType,TRUE,TermInfo . Version,TermInfo . Revision);
}
else
{
if(!ReadConfigChunk(Handle,PrivatePhonebook[Index] -> Config,ConfigChunkType,Chunk -> cn_Size,NULL))
{
if(Count)
CurrentPhoneSize = Count - 1;
else
CurrentPhoneSize = 0;
break;
}
else
FixOldConfig(PrivatePhonebook[Index] -> Config,ConfigChunkType,TRUE,TermInfo . Version,TermInfo . Revision);
}
}
// Special treatment for obsolete "FILE" chunk
if(Chunk -> cn_ID == ID_FILE)
{
struct Configuration *Config = PrivatePhonebook[Index] -> Config;
LONG i;
for(i = PREF_TRANSLATIONFILENAME ; i <= PREF_FASTMACROFILENAME ; i++)
{
if(!CreateConfigEntry(Config,i))
{
Error = ERROR_NO_FREE_STORE;
break;
}
}
if(!Error)
{
strcpy(Config -> TranslationFileName, Config -> FileConfig -> TranslationFileName);
strcpy(Config -> MacroFileName, Config -> FileConfig -> MacroFileName);
strcpy(Config -> CursorFileName, Config -> FileConfig -> CursorFileName);
strcpy(Config -> FastMacroFileName, Config -> FileConfig -> FastMacroFileName);
DeleteConfigEntry(Config,PREF_FILE);
}
}
if(Chunk -> cn_ID == ID_DATE)
{
if(!PrivatePhonebook[Index] -> Header -> NoRates)
{
WORD Count = (Chunk -> cn_Size - sizeof(struct TimeDateHeader)) / sizeof(struct TimeDate);
if(!CurrentPhoneSize)
break;
if(TimeDateNode = CreateTimeDateNode(-1,-1,"",Count))
{
if(ReadChunkBytes(Handle,&TimeDateNode -> Header,sizeof(struct TimeDateHeader)) == sizeof(struct TimeDateHeader))
{
if(ReadChunkRecords(Handle,TimeDateNode -> Table,sizeof(struct TimeDate),Count) == Count)
{
AdaptTimeDateNode(TimeDateNode);
AddTail((struct List *)&PrivatePhonebook[Index] -> TimeDateList,&TimeDateNode -> VanillaNode);
LastHadTime = TRUE;
}
else
{
Error = IoErr();
FreeTimeDateNode(TimeDateNode);
}
}
else
{
Error = IoErr();
FreeTimeDateNode(TimeDateNode);
}
}
}
}
}
if(CurrentPhoneSize && !Error)
{
LONG i;
if(!LastHadTime)
{
if(TimeDateNode = CreateTimeDateNode(-1,-1,"",2))
AddTail((struct List *)&PrivatePhonebook[Index] -> TimeDateList,&TimeDateNode -> VanillaNode);
}
DB(for(i = 0 ; i < CurrentPhoneSize ; i++))
DB(kprintf("0x%08lx |%s|\n",PrivatePhonebook[i] -> Header -> ID,PrivatePhonebook[i] -> Header -> Name));
if(BookHandle)
{
BookHandle -> PhonebookID = PrivatePhonebookID;
if(BookHandle -> Phonebook)
DeletePhonebook(BookHandle -> Phonebook,BookHandle -> PhoneSize,TRUE);
BookHandle -> Phonebook = PrivatePhonebook;
BookHandle -> PhoneSize = PrivatePhoneSize;
BookHandle -> NumPhoneEntries = CurrentPhoneSize;
BookHandle -> DefaultGroup = Globals . DefaultGroup;
BookHandle -> AutoDial = Globals . AutoDial;
BookHandle -> AutoExit = Globals . AutoExit;
if(BookHandle -> PhoneGroupList)
{
DeletePhoneGroupList(BookHandle -> PhoneGroupList);
MoveList((struct List *)&LocalPhoneGroupList,(struct List *)BookHandle -> PhoneGroupList);
}
else
DeletePhoneGroupList(&LocalPhoneGroupList);
memcpy(BookHandle -> PhonePassword,PasswordBuffer,20);
BookHandle -> PhonePasswordUsed = UsePhonePassword;
for(i = BookHandle -> NumPhoneEntries ; i < BookHandle -> PhoneSize ; i++)
{
if(BookHandle -> Phonebook[i])
{
if(BookHandle -> Phonebook[i] -> Config)
DeleteConfiguration(BookHandle -> Phonebook[i] -> Config);
FreeVecPooled(BookHandle -> Phonebook[i]);
BookHandle -> Phonebook[i] = NULL;
}
}
for(i = 0 ; i < BookHandle -> NumPhoneEntries ; i++)
FinalFix(BookHandle -> Phonebook[i] -> Config,TRUE,TermInfo . Version,TermInfo . Revision);
}
else
{
PhonebookID = PrivatePhonebookID;
if(Phonebook)
DeletePhonebook(Phonebook,PhoneSize,TRUE);
Phonebook = PrivatePhonebook;
PhoneSize = PrivatePhoneSize;
NumPhoneEntries = CurrentPhoneSize;
PhonebookDefaultGroup = Globals . DefaultGroup;
PhonebookAutoDial = Globals . AutoDial;
PhonebookAutoExit = Globals . AutoExit;
DeletePhoneGroupList(&PhoneGroupList);
MoveList((struct List *)&LocalPhoneGroupList,(struct List *)&PhoneGroupList);
memcpy(PhonePassword,PasswordBuffer,20);
PhonePasswordUsed = UsePhonePassword;
for(i = NumPhoneEntries ; i < PhoneSize ; i++)
{
if(Phonebook[i])
{
if(Phonebook[i] -> Config)
DeleteConfiguration(Phonebook[i] -> Config);
FreeVecPooled(Phonebook[i]);
Phonebook[i] = NULL;
}
}
for(i = 0 ; i < NumPhoneEntries ; i++)
FinalFix(Phonebook[i] -> Config,TRUE,TermInfo . Version,TermInfo . Revision);
}
FreeDialList(TRUE);
Success = TRUE;
}
else
{
DeletePhoneGroupList(&LocalPhoneGroupList);
if(PrivatePhoneSize)
{
DeletePhonebook(PrivatePhonebook,PrivatePhoneSize,TRUE);
Success = FALSE;
}
}
}
CloseIFF(Handle);
}
Close(Handle -> iff_Stream);
}
else
Error = IoErr();
FreeIFF(Handle);
}
else
Error = ERR_NO_MEM;
if(Error)
SetIoErr(Error);
if(UseOld)
return(LoadOldPhonebook(Name,BookHandle));
else
return(Success);
}
/* WriteConfig(STRPTR Name,struct Configuration *Config):
*
* Write the configuration to a file, very much like
* WriteIFFData().
*/
BYTE __regargs
WriteConfig(STRPTR Name,struct Configuration *Config)
{
struct IFFHandle *Handle;
BYTE Success = FALSE;
LONG Error = 0;
/* Allocate a handle. */
if(Handle = AllocIFF())
{
/* Open an output stream. */
if(Handle -> iff_Stream = Open(Name,MODE_NEWFILE))
{
/* Tell iffparse that this is
* a DOS handle.
*/
InitIFFasDOS(Handle);
/* Open the handle for writing. */
if(!(Error = OpenIFF(Handle,IFFF_WRITE)))
{
/* Push outmost chunk onto stack. */
if(!(Error = PushChunk(Handle,ID_TERM,ID_FORM,IFFSIZE_UNKNOWN)))
{
/* Add a version identifier. */
if(!(Error = PushChunk(Handle,0,ID_VERS,IFFSIZE_UNKNOWN)))
{
struct TermInfo TermInfo;
TermInfo . Version = CONFIG_FILE_VERSION;
TermInfo . Revision = CONFIG_FILE_REVISION;
/* Update the other configuration pointer as well. */
Config -> SerialConfig -> LastVersionSaved = TermVersion;
Config -> SerialConfig -> LastRevisionSaved = TermRevision;
/* Write the version data. */
if(WriteChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
{
/* Pop the version chunk, i.e. write it to the file. */
if(Error = PopChunk(Handle))
Success = FALSE;
else
{
if(WriteConfigChunks(Handle,Config,NULL,NULL))
{
LONG i;
Success = TRUE;
for(i = 0 ; Success && i < WINDOW_COUNT ; i++)
{
if(!(Error = PushChunk(Handle,0,ID_WINF,sizeof(struct WindowInfo))))
{
if(WriteChunkBytes(Handle,&WindowInfoTable[i],sizeof(struct WindowInfo)) == sizeof(struct WindowInfo))
{
if(Error = PopChunk(Handle))
Success = FALSE;
}
else
{
Error = IoErr();
Success = FALSE;
}
}
else
Success = FALSE;
}
}
}
}
else
{
Error = IoErr();
Success = FALSE;
}
}
/* Seems that we're done, now try to pop the FORM chunk
* and return.
*/
if(Success)
{
if(Error = PopChunk(Handle))
Success = FALSE;
}
}
/* Close the handle (flush any pending data). */
CloseIFF(Handle);
}
/* Close the DOS handle itself. */
Close(Handle -> iff_Stream);
}
else
Error = IoErr();
/* And free the IFF handle. */
FreeIFF(Handle);
}
else
Error = ERR_NO_MEM;
if(Success)
AddProtection(Name,FIBF_EXECUTE);
return(Success);
}
/* ReadConfig(STRPTR Name,struct Configuration *Config):
*
* Read the configuration file, very much the same as ReadIFFData().
*/
BYTE __regargs
ReadConfig(STRPTR Name,struct Configuration *Config)
{
struct IFFHandle *Handle;
BYTE Success = FALSE,
UseOld = FALSE;
struct ContextNode *Chunk;
UBYTE ConfigChunkType;
LONG Error = 0;
if(Handle = AllocIFF())
{
if(Handle -> iff_Stream = Open(Name,MODE_OLDFILE))
{
InitIFFasDOS(Handle);
if(!(Error = OpenIFF(Handle,IFFF_READ)))
{
if(!StopChunks(Handle,Stops,NUM_STOPS))
{
struct TermInfo TermInfo;
while(!ParseIFF(Handle,IFFPARSE_SCAN))
{
Chunk = CurrentChunk(Handle);
/* Oops! Some is trying to
* use the phone book file as
* a configuration file.
*/
if(Chunk -> cn_ID == ID_CAT)
{
Success = FALSE;
break;
}
if(Chunk -> cn_ID == ID_VERS)
{
if(ReadChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
{
if(TermInfo . Version != CONFIG_FILE_VERSION || (TermInfo . Version == CONFIG_FILE_VERSION && TermInfo . Revision > CONFIG_FILE_REVISION))
{
if(TermInfo . Version == 2 && TermInfo . Revision == 4)
UseOld = TRUE;
if(TermInfo . Version != 3)
break;
}
}
else
{
Error = IoErr();
break;
}
}
if(Chunk -> cn_ID == ID_WINF)
{
struct WindowInfo Info;
if(ReadChunkBytes(Handle,&Info,sizeof(Info)) == sizeof(Info))
{
Success = TRUE;
ReplaceWindowInfo(&Info);
}
else
{
Error = IoErr();
Success = FALSE;
break;
}
}
else
{
if(ConfigChunkType = IsConfigChunk(Chunk -> cn_ID))
{
if(ReadConfigChunk(Handle,Config,ConfigChunkType,Chunk -> cn_Size,NULL))
{
FixOldConfig(Config,ConfigChunkType,FALSE,TermInfo . Version,TermInfo . Revision);
Success = TRUE;
}
else
{
Error = IoErr();
Success = FALSE;
break;
}
}
// Special treatment for obsolete "FILE" chunk
if(Chunk -> cn_ID == ID_FILE)
{
struct Configuration *LocalConfig = Config;
LONG i;
for(i = PREF_TRANSLATIONFILENAME ; i <= PREF_FASTMACROFILENAME ; i++)
{
if(!CreateConfigEntry(LocalConfig,i))
{
Error = ERROR_NO_FREE_STORE;
Success = FALSE;
break;
}
}
if(!Error)
{
strcpy(LocalConfig -> TranslationFileName, LocalConfig -> FileConfig -> TranslationFileName);
strcpy(LocalConfig -> MacroFileName, LocalConfig -> FileConfig -> MacroFileName);
strcpy(LocalConfig -> CursorFileName, LocalConfig -> FileConfig -> CursorFileName);
strcpy(LocalConfig -> FastMacroFileName, LocalConfig -> FileConfig -> FastMacroFileName);
DeleteConfigEntry(LocalConfig,PREF_FILE);
}
}
}
}
if(Success)
FinalFix(Config,FALSE,TermInfo . Version,TermInfo . Revision);
}
CloseIFF(Handle);
}
Close(Handle -> iff_Stream);
}
FreeIFF(Handle);
}
else
Error = IoErr();
if(Error)
SetIoErr(Error);
if(UseOld)
return(ReadOldConfig(Name,Config));
else
return(Success);
}